{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 二分类\n",
    "1. 矩阵由于循环\n",
    "2. 前向传播和反向传播\n",
    "3. 逻辑回归(l**ogistic regression**)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/e173fd42de5f1953deb617623d5087e8.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**符号定义** ：\n",
    "\n",
    "$x$：表示一个$n_x$维数据，为输入数据，维度为$(n_x,1)$； \n",
    "\n",
    "$y​$：表示输出结果，取值为$(0,1)​$；\n",
    "\n",
    "$(x^{(i)},y^{(i)})$：表示第$i$组数据，可能是训练数据，也可能是测试数据，此处默认为训练数据； \n",
    "\n",
    "$X=[x^{(1)},x^{(2)},...,x^{(m)}]$：表示所有的训练数据集的输入值，放在一个 $n_x×m$的矩阵中，其中$m$表示样本数目; \n",
    "\n",
    "$Y=[y^{(1)},y^{(2)},...,y^{(m)}]$：对应表示所有训练数据集的输出值，维度为$1×m$。\n",
    "\n",
    "用一对$(x,y)$来表示一个单独的样本，$x$代表$n_x$维的特征向量，$y$ 表示标签(输出结果)只能为0或1。\n",
    "而训练集将由$m$个训练样本组成，其中$(x^{(1)},y^{(1)})$表示第一个样本的输入和输出，$(x^{(2)},y^{(2)})$表示第二个样本的输入和输出，直到最后一个样本$(x^{(m)},y^{(m)})$，然后所有的这些一起表示整个训练集。有时候为了强调这是训练样本的个数，会写作$M_{train}$，当涉及到测试集的时候，我们会使用$M_{test}$来表示测试集的样本数，所以这是测试集的样本数："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/55345ba411053da11ff843bbb3406369.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "X=np.ones((3,2))\n",
    "X.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 逻辑回归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/dfb5731c30b81eced917450d31e860a3.png\">\n",
    "<img style=\"float:left\" src=\"../images/7e304debcca5945a3443d56bcbdd2964.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 逻辑回归的代价函数\n",
    "**为什么需要代价函数：**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/4c9a27b071ce9162dbbcdad3393061d2.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "训练样本$i$所对应的预测值是${\\hat y}^{(i)}$,是用训练样本的${w}^{T}{x}^{(i)}+b$然后通过**sigmoid**函数来得到，也可以把$z$定义为${z}^{(i)}={w}^{T}{x}^{(i)}+b$,我们将使用这个符号$(i)$注解，上标$(i)$来指明数据表示$x$或者$y$或者$z$或者其他数据的第$i$个训练样本，这就是上标$(i)$的含义。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**损失函数：**\n",
    "\n",
    "损失函数又叫做误差函数，用来衡量算法的运行情况，**Loss function:$L\\left( \\hat{y},y \\right)$.**\n",
    "\n",
    "逻辑回归中用到的损失函数是：$L\\left( \\hat{y},y \\right)=-y\\log(\\hat{y})-(1-y)\\log (1-\\hat{y})$\n",
    ">* 当$y=1$时损失函数$L=-\\log (\\hat{y})$，如果想要损失函数$L$尽可能得小，那么$\\hat{y}$就要尽可能大，因为**sigmoid**函数取值$[0,1]$，所以$\\hat{y}$会无限接近于1。\n",
    "* 当$y=0$时损失函数$L=-\\log (1-\\hat{y})$，如果想要损失函数$L$尽可能得小，那么$\\hat{y}$就要尽可能小，因为**sigmoid**函数取值$[0,1]$，所以$\\hat{y}$会无限接近于0。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**代价函数:**\n",
    "\n",
    "$J\\left( w,b \\right)=\\frac{1}{m}\\sum\\limits_{i=1}^{m}{L\\left( {\\hat{y}}^{(i)},{y}^{(i)} \\right)}=\\frac{1}{m}\\sum\\limits_{i=1}^{m}{\\left (-{y}^{(i)}\\log {\\hat{y}}^{(i)}-(1-{y}^{(i)})\\log {(1-{\\hat{y}}^{(i)})} \\right)}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 梯度下降法\n",
    "## **梯度下降法可以做什么？**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/cbd5ff8c461fcb5a699c4ec4789687b3.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/a3c81d2c8629d674141def47dc02f312.jpg\">\n",
    "<img style=\"float:left\" src=\"../images/236774be30d12524a2002c3c484d22d5.jpg\">\n",
    "<img style=\"float:left\" src=\"../images/af11ecd5d72c85f777592f8660678ce6.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **梯度下降步骤：**\n",
    "\n",
    "**1. 初始化$w$和$b$，**\n",
    "\n",
    "可以用如图那个小红点来初始化参数$w$和$b$，也可以采用随机初始化的方法，对于逻辑回归几乎所有的初始化方法都有效，因为函数是凸函数，无论在哪里初始化，应该达到同一点或大致相同的点。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/0ad6c298d0ac25ca9b26546bb06d462c.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2. 朝最陡的下坡方向走一步，不断地迭代**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/bb909b874b2865e66eaf9a5d18cc00e5.jpg\">\n",
    "<img style=\"float:left\" src=\"../images/c5eda5608fd2f4d846559ed8e89ed33c.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3.直到走到全局最优解或者接近全局最优解的地方**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/1b79cca8e1902f0ee24b4eb966755ddd.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **梯度下降法的细节化说明（仅有一个参数）**\n",
    "假定代价函数（成本函数）$J(w)$ 只有一个参数$w$，即用一维曲线代替多维曲线，这样可以更好画出图像。\n",
    "\n",
    "$w:=w-a\\frac{\\mathrm{d} J(w)}{\\mathrm{d}w}$\n",
    "\n",
    "$:=$表示更新参数,\n",
    "\n",
    "$a $ 表示学习率（**learning rate**），用来控制步长（**step**），即向下走一步的长度$\\frac{dJ(w)}{dw}$  就是函数$J(w)$对$w$ 求导（**derivative**），在代码中我们会使用$dw$表示这个结果"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/4fb3b91114ecb2cd81ec9f3662434d81.jpg\">\n",
    "<img style=\"float:left\" src=\"../images/21541fc771ad8895c18d292dd4734fe7.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **梯度下降法的细节化说明（两个参数）**\n",
    "$w:=w-a\\frac{\\partial J(w,b)}{\\partial w}$\n",
    "\n",
    "$b:=b-a\\frac{\\partial J(w,b)}{\\partial b}$\n",
    "\n",
    "$\\partial$ 表示求偏导符号，\n",
    "$\\frac{\\partial J(w,b)}{\\partial w}$  就是函数$J(w,b)$ 对$w$ 求偏导，在代码中我们会使用$dw$ 表示这个结果，\n",
    "$\\frac{\\partial J(w,b)}{\\partial b}$  就是函数$J(w,b)$对$b$ 求偏导，在代码中我们会使用$db$ 表示这个结果，\n",
    "小写字母$d$ 用在求导数（**derivative**），即函数只有一个参数，\n",
    "偏导数符号$\\partial $ 用在求偏导（**partial derivative**），即函数含有两个以上的参数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 导数\n",
    "<img style=\"float:left\" src=\"../images/efe674e73c693a0c5439b68652ed2ce1.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 更多的导数例子\n",
    "<img style=\"float:left\" src=\"../images/c34ba67cca6cb94c79a2e63cc5749c1f.png\">\n",
    "<img style=\"float:left\" src=\"../images/5b78b725478a0b4def09539f54c784be.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 计算图\n",
    "一个神经网络的计算，都是按照前向或反向传播过程组织的。首先我们计算出一个新的网络的输出（前向过程），紧接着进行一个反向传输操作。后者我们用来计算出对应的梯度或导数。计算图解释了为什么我们用这种方式组织这些计算过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/5216254e20325aad2dd51975bbc70068.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 使用计算图求导数\n",
    "下面用到的公式：\n",
    "\n",
    "$\\frac{dJ}{du}=\\frac{dJ}{dv}\\frac{dv}{du}$  ，         $\\frac{dJ}{db}=\\frac{dJ}{du}\\frac{du}{db}$ ，          $\\frac{dJ}{da}=\\frac{dJ}{du}\\frac{du}{da}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/cd75ffa2793fa4af02bdd869fe962bc1.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 逻辑回归中的梯度下降\n",
    "假设样本只有两个特征${x}_{1}$和${x}_{2}$，为了计算$z$，我们需要输入参数${w}_{1}$、${w}_{2}$ 和$b$，除此之外还有特征值${x}_{1}$和${x}_{2}$。因此$z$的计算公式为：\n",
    "$z={w}_{1}{x}_{1}+{w}_{2}{x}_{2}+b$ \n",
    "\n",
    "回想一下逻辑回归的公式定义如下：\n",
    "$\\hat{y}=a=\\sigma (z)$\n",
    "其中$z={w}^{T}x+b$，\n",
    "$\\sigma \\left( z \\right)=\\frac{1}{1+{e}^{-z}}$\n",
    "\n",
    "损失函数：\n",
    "$L( {\\hat{y}}^{(i)},{y}^{(i)})=-{y}^{(i)}\\log {\\hat{y}^{(i)}}-(1-{y}^{(i)})\\log (1-{\\hat{y}}^{(i)})$ \n",
    "\n",
    "代价函数：\n",
    "$J\\left( w,b \\right)=\\frac{1}{m}\\sum\\nolimits_{i}^{m}{L({\\hat{y}}^{(i)},{y}^{(i)})}$ \n",
    "\n",
    "假设现在只考虑单个样本的情况，单个样本的代价函数定义如下：\n",
    "$L(a,y)=-(y\\log (a)+(1-y)\\log (1-a))$ \n",
    "其中$a$是逻辑回归的输出，$y$是样本的标签值。\n",
    "\n",
    "现在让我们画出表示这个计算的计算图。\n",
    "这里先复习下梯度下降法，$w$和$b$的修正量可以表达如下：\n",
    "\n",
    "$w:=w-a \\frac{\\partial J(w,b)}{\\partial w}$，$b:=b-a\\frac{\\partial J(w,b)}{\\partial b}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/03f5f96177ab15d5ead8298ba50300ac.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "前面我们已经讲解了如何在单个训练样本上计算代价函数的前向步骤。\n",
    "\n",
    "现在让我们来讨论通过**反向计算出导数**。因为我们想要计算出的代价函数$L(a,y)$的导数，首先我们需要反向计算出代价函数$L(a,y)$关于$a$的导数，在编写代码时，你只需要用$da$ 来表示$\\frac{dL(a,y)}{da}$  。\n",
    "通过微积分得到：\n",
    "$\\frac{dL(a,y)}{da}=-y/a+(1-y)/(1-a)$ 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**可以再反向一步**，在编写**Python**代码时，你只需要用$dz$来表示代价函数$L$关于$z$ 的导数$\\frac{dL}{dz}$，也可以写成$\\frac{dL(a,y)}{dz}$。\n",
    "\n",
    "$\\frac{dL}{dz}=a-y$ 。\n",
    "因为$\\frac{dL(a,y)}{dz}=\\frac{dL}{dz}=(\\frac{dL}{da})\\cdot (\\frac{da}{dz})$，并且$\\frac{da}{dz}=a\\cdot (1-a)$，\n",
    "而 $\\frac{dL}{da}=(-\\frac{y}{a}+\\frac{(1-y)}{(1-a)})$，因此将这两项相乘，得到：\n",
    "\n",
    "${dz} = \\frac{{dL}(a,y)}{dz} = \\frac{dL}{dz} = \\left( \\frac{dL}{da} \\right) \\cdot \\left(\\frac{da}{dz} \\right) = ( - \\frac{y}{a} + \\frac{(1 - y)}{(1 - a)})\\cdot a(1 - a) = a - y$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**最后一步反向推导**，也就是计算$w$和$b$变化对代价函数$L$的影响，可以用:<br>\n",
    "$d{w}_{1}=\\frac{1}{m}\\sum\\limits_{i}^{m}{x_{1}^{(i)}}({a}^{(i)}-{y}^{(i)})$ <br>\n",
    "$d{w}_{2}=\\frac{1}{m}\\sum\\limits_{i}^{m}{x_{2}^{(i)}}({a}^{(i)}-{y}^{(i)})$ <br>\n",
    "$db=\\frac{1}{m}\\sum\\limits_{i}^{m}{({a}^{(i)}-{y}^{(i)})}$ \n",
    "\n",
    "$d{w}_{1}$ 表示$\\frac{\\partial L}{\\partial {w}_{1}}={x}_{1}\\cdot dz$， <br>\n",
    "$d{w}_{\\text{2}}$ 表示$\\frac{\\partial L}{\\partial {w}_{2}}={x}_{2}\\cdot dz$，<br>\n",
    "$db=dz$。\n",
    "\n",
    "因此，关于单个样本的梯度下降算法，你所需要做的就是如下的事情：<br>\n",
    "使用$dz=(a-y)$计算$dz$，<br>\n",
    "使用$d{w}_{1}={x}_{1}\\cdot dz$计算$d{w}_{1}$， <br>\n",
    "使用$d{w}_{2}={x}_{2}\\cdot dz$计算$d{w}_{2}$，<br>\n",
    "使用$db=dz$ 来计算$db$，<br>\n",
    "然后:<br>\n",
    "${w}_{1}:={w}_{1}-a d{w}_{1}$，<br>\n",
    "${w}_{2}:={w}_{2}-a d{w}_{2}$，<br>\n",
    "$b:=b-\\alpha db$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/6403f00e5844c3100f4aa9ff043e2319.jpg\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# m个样本的梯度下降"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/bf930b1f68d8e0726dda5393afc83672.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**代价函数：**\n",
    "$J\\left( w,b \\right)=\\frac{1}{m}\\sum\\nolimits_{i}^{m}{L({\\hat{y}}^{(i)},{y}^{(i)})}$ \n",
    "\n",
    "**反向传播**的全局梯度值：<br>\n",
    "$d{w}_{1}=\\frac{1}{m}\\sum\\limits_{i}^{m}{x_{1}^{(i)}}({a}^{(i)}-{y}^{(i)})$ <br>\n",
    "$d{w}_{2}=\\frac{1}{m}\\sum\\limits_{i}^{m}{x_{2}^{(i)}}({a}^{(i)}-{y}^{(i)})$ <br>\n",
    "$db=\\frac{1}{m}\\sum\\limits_{i}^{m}{({a}^{(i)}-{y}^{(i)})}$ \n",
    "\n",
    "**迭代梯度下降：**<br>\n",
    "${w}_{1}:={w}_{1}-a d{w}_{1}$，<br>\n",
    "${w}_{2}:={w}_{2}-a d{w}_{2}$，<br>\n",
    "$b:=b-\\alpha db$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/8b725e51dcffc53a5def49438b70d925.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "代码流程：\n",
    "\n",
    "```\n",
    "J=0;dw1=0;dw2=0;db=0;\n",
    "for i = 1 to m\n",
    "    z(i) = wx(i)+b;\n",
    "    a(i) = sigmoid(z(i));\n",
    "    J += -[y(i)log(a(i))+(1-y(i)）log(1-a(i));\n",
    "    dz(i) = a(i)-y(i);\n",
    "    dw1 += x1(i)dz(i);\n",
    "    dw2 += x2(i)dz(i);\n",
    "    db += dz(i);\n",
    "J/= m;\n",
    "dw1/= m;\n",
    "dw2/= m;\n",
    "db/= m;\n",
    "w=w-alpha*dw\n",
    "b=b-alpha*db\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 向量化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在单一样本的逻辑回归中我们需要去计算$z={w}^{T}x+b$，$w$、$x$都是列向量。如果我们有很多的特征，那么就会有一个非常大的向量，其中$w\\in {\\mathbb{R}}^{n_x}$ , $x\\in{\\mathbb{R}}^{n_x}$，所以如果想使用非向量化方法去计算$w^Tx$，需要用如下方式：\n",
    "\n",
    "```\n",
    "z=0\n",
    "for i in range(n_x)\n",
    "\n",
    "    z+=w[i]*x[i]\n",
    "z+=b\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**向量化实现**\n",
    "```\n",
    "z=np.dot(w,x)+b\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**代码案例：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "向量计算:1.0006427764892578ms\n",
      "普通循环:474.7426509857178ms\n"
     ]
    }
   ],
   "source": [
    "import numpy as np #导入numpy库\n",
    "a = np.array([1,2,3,4]) #创建一个数据a\n",
    "print(a)\n",
    "# [1 2 3 4]\n",
    "import time #导入时间库\n",
    "a = np.random.rand(1000000)\n",
    "b = np.random.rand(1000000) #通过round随机得到两个一百万维度的数组\n",
    "tic = time.time() #现在测量一下当前时间\n",
    "#向量化的版本\n",
    "c = np.dot(a,b)\n",
    "toc = time.time()\n",
    "print(\"向量计算:\" + str(1000*(toc-tic)) +\"ms\") #打印一下向量化的版本的时间\n",
    "\n",
    "#继续增加非向量化的版本\n",
    "c = 0\n",
    "tic = time.time()\n",
    "for i in range(1000000):\n",
    "    c += a[i]*b[i]\n",
    "toc = time.time()\n",
    "print(\"普通循环:\" + str(1000*(toc-tic)) + \"ms\")#打印for循环的版本的时间"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 向量化的更多例子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=np.arange(4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.        ,  2.71828183,  7.3890561 , 20.08553692])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.69314718, 1.09861229, 1.38629436])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.log(a+1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 2, 3])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(a,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 4, 9], dtype=int32)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.5, 1. , 1.5])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用向量算法替代for循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<img style=\"float:left\" src=\"../images/af298e37ade1883eaeb44c822e279d42.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**去除第一层for循环的代码流程：**\n",
    "\n",
    "```\n",
    "J=0;dw=np.zeros((n,1));db=0;\n",
    "for i = 1 to m\n",
    "    z(i) = wx(i)+b;\n",
    "    a(i) = sigmoid(z(i));\n",
    "    J += -[y(i)log(a(i))+(1-y(i)）log(1-a(i));\n",
    "    dz(i) = a(i)-y(i);\n",
    "    dw += x(i)dz(i)\n",
    "    db += dz(i);\n",
    "J/= m;\n",
    "dw1/= m;\n",
    "dw2/= m;\n",
    "dw=dw.mean()\n",
    "db/= m;\n",
    "w=w-alpha*dw\n",
    "b=b-alpha*db\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 向量化逻辑回归\n",
    "**去除第二层for循环的代码流程：**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "variables": {
     "0:{1": "<p><strong>SyntaxError</strong>: unexpected EOF while parsing (<ipython-input-20-8fa524e0c5cf>, line 1)</p>\n",
     "0:{2": "<p><strong>SyntaxError</strong>: unexpected EOF while parsing (<ipython-input-20-e2d8b75ae7e9>, line 1)</p>\n",
     "{{0:{1": "<p><strong>SyntaxError</strong>: unexpected EOF while parsing (<ipython-input-20-11c27b795c75>, line 1)</p>\n"
    }
   },
   "outputs": [],
   "source": [
    "import sympy as sp\n",
    "sp.init_printing()\n",
    "def getM(var_name,r,c):\n",
    "    \"\"\"\n",
    "    make a sympy s matrix\n",
    "    :param var_name:the symbol name\n",
    "    :param r:matrix s rows\n",
    "    :param c:matrix s cols\n",
    "    \"\"\"\n",
    "    if r>1 and c>1:\n",
    "        ss=sp.symbols(\"{0}_{{{{0:{1}}}{{0:{2}}}}}\".format(var_name,r,c))        \n",
    "    elif r==1:\n",
    "        ss=sp.symbols(\"{0}_{{0:{1}}}\".format(var_name,c))\n",
    "    elif c==1:\n",
    "        ss=sp.symbols(\"{0}_{{0:{1}}}\".format(var_name,r))\n",
    "    else:\n",
    "        raise Exception('invalid input parameter！')\n",
    "    return sp.Matrix([ss[i*c:(i+1)*c] for i in range(r)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**构造矩阵，前向传播**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img style=\"float:left\" src=\"../images/3a8a0c9ed33cd6c033103e35c26eeeb7.png\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left ( \\left[\\begin{matrix}x_{{0}{0}} & x_{{0}{1}} & x_{{0}{2}}\\\\x_{{1}{0}} & x_{{1}{1}} & x_{{1}{2}}\\\\x_{{2}{0}} & x_{{2}{1}} & x_{{2}{2}}\\\\x_{{3}{0}} & x_{{3}{1}} & x_{{3}{2}}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}w_{0}\\\\w_{1}\\\\w_{2}\\\\w_{3}\\end{matrix}\\right], \\quad \\left[\\begin{matrix}b_{0} & b_{1} & b_{2}\\end{matrix}\\right]\\right )$$"
      ],
      "text/plain": [
       "⎛⎡x_{{0}{0}}  x_{{0}{1}}  x_{{0}{2}}⎤  ⎡w_{0}⎤                       ⎞\n",
       "⎜⎢                                  ⎥  ⎢     ⎥                       ⎟\n",
       "⎜⎢x_{{1}{0}}  x_{{1}{1}}  x_{{1}{2}}⎥  ⎢w_{1}⎥                       ⎟\n",
       "⎜⎢                                  ⎥, ⎢     ⎥, [b_{0}  b_{1}  b_{2}]⎟\n",
       "⎜⎢x_{{2}{0}}  x_{{2}{1}}  x_{{2}{2}}⎥  ⎢w_{2}⎥                       ⎟\n",
       "⎜⎢                                  ⎥  ⎢     ⎥                       ⎟\n",
       "⎝⎣x_{{3}{0}}  x_{{3}{1}}  x_{{3}{2}}⎦  ⎣w_{3}⎦                       ⎠"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m,n=3,4\n",
    "X=getM('x',n,m)\n",
    "W=getM('w',n,1)\n",
    "B=getM('b',1,m)\n",
    "X,W,B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}b_{0} + w_{0} x_{{0}{0}} + w_{1} x_{{1}{0}} + w_{2} x_{{2}{0}} + w_{3} x_{{3}{0}}\\end{matrix}\\right]$$"
      ],
      "text/plain": [
       "[b_{0} + w_{0}⋅x_{{0}{0}} + w_{1}⋅x_{{1}{0}} + w_{2}⋅x_{{2}{0}} + w_{3}⋅x_{{3}\n",
       "{0}}]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z1=W.T*X[:,[0]]+B[[0],0]\n",
    "Z1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAANcAAAAiCAYAAADMIkwfAAAABHNCSVQICAgIfAhkiAAAA8hJREFUeJzt3FmIHEUYwPGfwaCriazRgBCPJUZBMBpFxRclIh4rMQ8moA+i0QcPEB9EiAoRQVSCLyIeUZSsByhoEDzwgHggghLBGER9EBEhQQUPVAyouD5UDTvbTE/37vQcWb4/NFvT83XVf2qmur6p6W2CUed8vIZ9mMbG4eoEdVk0bIGgksPxOW4ZtkgQLGRi5jqAiJkrCPpEDK4g6BMxuIKgT8TgCoI+EYMrCPrEwcMWCCpZglVtjyewBr/g+2EIBcFCYa20BF/cpoanFARBEARBEARBEATD5aD8d3qoFkEQBEEwLNbh8WFLBMEo0PQVGqfhs4brDIIDkn4MrpPxKb7C6obqPQlv5/Jl2J/Ly/FJyTEf4dxcfhK3N+TShBuj7TfKbgzOb6T4Erfl8iY811C9y6UOhVekwXuI1Kk3lhxzKV7FrdjekEdTbqPuN8pug/Qro9atF+Z6beEXJfsvxs8Yw0N53x5c2WOd+3L5V+nf3SfwN77GeK7/gpLj38J9uCLXNR/65TbqfqPs1pRfJ6bwHe6piGvdemE7dpQFFQfXsdiKSSll3Imb8VN+/tQuDZ4ppYL/5cdnYDeW4pG8/2W8UTiuW50t/pV+NrhJSgM2Yr10pvuzpI2zsQx7pTdOSVw3vybcJnA3DsNVbcd18ivGDqLvJrEBR+W2dpa4dYrrd9+dg+uwAk9Js5USv2Lse13ceuXNvNVmJX7EAzhFuvL6gyxWh03SmWcxjsYuHINrcEmOeWEuQgX24EPpzdgqDeTT83PFNlZIZ5aV2WNNSVzZvibdWrzYVi7zK8YOou9ajOOJGm6tuKb86rgdiQdzucqvFTsftynVs1aR0rSwfUFjG57GndIL3I37cWHNRlZLU+QuvI8t+EHqjL1tIvNlUa5/Gr/jN6mTFdo4FC9J+fi3+TVs6RA33WVfk25Fxrr4FRlE37XYjGdruG02M7gG0XdX4x28rrrv2mOb6rueOSEL/CVNx61tvzSb9cK1ZvLiXs6+TbTRKW4QfsyeuerGDsrtXlw0j7hB+S1WP4NqxdZxu8vsz/s/UprZvu+8ivYq78i1XjpjrOqwHVdReRVH4BkpD768x7p6baNTXL/9xqWs4BszK6l1YwfRd9dLWco23DDHuH77rcNjUrq2YY6xddyWmf1Z34GHC/vGKtqtHFyT0pfLpRUVBcFCZkofvnN9LC2LPi+t8p0oTf+Pmrm4NwiCxBJpIaW1mDKRy8eXHXAW3pXSwz+kFOCOvioGwWgxpd7MtVbceiEIgiAIgiAIgiAIgoXI/+mcWE6Imzd7AAAAAElFTkSuQmCC\n",
      "text/latex": [
       "$$\\frac{1}{e^{- b_{0} - w_{0} x_{{0}{0}} - w_{1} x_{{1}{0}} - w_{2} x_{{2}{0}} - w_{3} x_{{3}{0}}} + 1}$$"
      ],
      "text/plain": [
       "                                           1                                  \n",
       "──────────────────────────────────────────────────────────────────────────────\n",
       " -b_{0} - w_{0}⋅x_{{0}{0}} - w_{1}⋅x_{{1}{0}} - w_{2}⋅x_{{2}{0}} - w_{3}⋅x_{{3\n",
       "ℯ                                                                             \n",
       "\n",
       "         \n",
       "─────────\n",
       "}{0}}    \n",
       "      + 1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A1=1/(1+sp.exp(-Z1)[0])\n",
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}b_{0} + w_{0} x_{{0}{0}} + w_{1} x_{{1}{0}} + w_{2} x_{{2}{0}} + w_{3} x_{{3}{0}} & b_{1} + w_{0} x_{{0}{1}} + w_{1} x_{{1}{1}} + w_{2} x_{{2}{1}} + w_{3} x_{{3}{1}} & b_{2} + w_{0} x_{{0}{2}} + w_{1} x_{{1}{2}} + w_{2} x_{{2}{2}} + w_{3} x_{{3}{2}}\\end{matrix}\\right]$$"
      ],
      "text/plain": [
       "[b_{0} + w_{0}⋅x_{{0}{0}} + w_{1}⋅x_{{1}{0}} + w_{2}⋅x_{{2}{0}} + w_{3}⋅x_{{3}\n",
       "{0}}  b_{1} + w_{0}⋅x_{{0}{1}} + w_{1}⋅x_{{1}{1}} + w_{2}⋅x_{{2}{1}} + w_{3}⋅x\n",
       "_{{3}{1}}  b_{2} + w_{0}⋅x_{{0}{2}} + w_{1}⋅x_{{1}{2}} + w_{2}⋅x_{{2}{2}} + w_\n",
       "{3}⋅x_{{3}{2}}]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Z=W.T*X+B\n",
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/latex": [
       "$$\\left[\\begin{matrix}\\frac{1}{e^{- b_{0} - w_{0} x_{{0}{0}} - w_{1} x_{{1}{0}} - w_{2} x_{{2}{0}} - w_{3} x_{{3}{0}}} + 1} & \\frac{1}{e^{- b_{1} - w_{0} x_{{0}{1}} - w_{1} x_{{1}{1}} - w_{2} x_{{2}{1}} - w_{3} x_{{3}{1}}} + 1} & \\frac{1}{e^{- b_{2} - w_{0} x_{{0}{2}} - w_{1} x_{{1}{2}} - w_{2} x_{{2}{2}} - w_{3} x_{{3}{2}}} + 1}\\end{matrix}\\right]$$"
      ],
      "text/plain": [
       "⎡                                           1                                 \n",
       "⎢─────────────────────────────────────────────────────────────────────────────\n",
       "⎢ -b_{0} - w_{0}⋅x_{{0}{0}} - w_{1}⋅x_{{1}{0}} - w_{2}⋅x_{{2}{0}} - w_{3}⋅x_{{\n",
       "⎣ℯ                                                                            \n",
       "\n",
       "                                                       1                      \n",
       "──────────  ──────────────────────────────────────────────────────────────────\n",
       "3}{0}}       -b_{1} - w_{0}⋅x_{{0}{1}} - w_{1}⋅x_{{1}{1}} - w_{2}⋅x_{{2}{1}} -\n",
       "       + 1  ℯ                                                                 \n",
       "\n",
       "                                                                  1           \n",
       "─────────────────────  ───────────────────────────────────────────────────────\n",
       " w_{3}⋅x_{{3}{1}}       -b_{2} - w_{0}⋅x_{{0}{2}} - w_{1}⋅x_{{1}{2}} - w_{2}⋅x\n",
       "                  + 1  ℯ                                                      \n",
       "\n",
       "                                ⎤\n",
       "────────────────────────────────⎥\n",
       "_{{2}{2}} - w_{3}⋅x_{{3}{2}}    ⎥\n",
       "                             + 1⎦"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A=Z.applyfunc(lambda x:1/(1+sp.E**(-x)))\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[ 1.11711755,  0.35454944,  0.1777668 ],\n",
       "        [-0.5513768 , -0.15913049,  0.27497068],\n",
       "        [-0.67076256,  0.5705479 , -2.92802511],\n",
       "        [ 0.80782945,  2.16104962, -1.71683675]]), array([[-0.40908726],\n",
       "        [ 0.03913573],\n",
       "        [-0.01835147],\n",
       "        [ 0.20966831]]), array([[-1.00599687, -1.35187798, -0.77622394]]))"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=np.random.randn(n,m)\n",
    "w=np.random.randn(n,1)\n",
    "b=np.random.randn(1,m)\n",
    "x,w,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.30288825, -1.06051411, -1.14441758]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=np.dot(w.T,x)+b\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.78632067, 0.74278878, 0.75848979]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=1/(1+np.exp(z))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 向量化逻辑回归的梯度输出\n",
    "之前我们在讲梯度计算的时候，逐个求解：<br> \n",
    "$dz^{(1)}=a^{(1)}-y^{(1)}$，<br>\n",
    "$dz^{(2)}=a^{(2)}-y^{(2)}$ ……等等一系列类似公式。\n",
    "\n",
    "现在，对 $m$个训练数据做同样的运算，我们可以定义一个新的变量：<br>\n",
    "$dZ=[dz^{(1)} ,dz^{(2)} ... dz^{(m)}]$，所有的 $dz$ 变量横向排列，因此，$dZ$ 是一个 $1\\times m$ 的矩阵，或者说，是一个$m$维行向量。\n",
    "\n",
    "之前的学习中，我们已经知道如何计算真实输出值$Y$的估计值$A$，<br>\n",
    "即 $[a^{(1)},a^{(2)} ... a^{(m)}]$,我们需要找到这样的一个行向量 $Y=[y^{(1)} y^{(2)} ... y^{(m)}]$ ，<br>\n",
    "由此，我们可以这样计算 $dZ=A-Y=[a^{(1)}-y^{(1)},a^{(2)}-y^{(2)},...,a^{(m)}-y^{(m)}]$，<br>\n",
    "不难发现第一个元素就是 $dz^{(1)}$，第二个元素就是 $dz^{(2)}$ ……所以我们现在仅需一行代码，就可以同时完成这所有的计算。\n",
    "\n",
    "在之前的实现中，我们已经去掉了一个逐个特征**for**循环，但我们仍有一个遍历训练集的循环，如下所示：\n",
    "\n",
    "$dw=0$<br>\n",
    "$dw + = x^{(1)}*{dz}^{(1)}$<br>\n",
    "$dw + = x^{(2)}\\ *dz^{(2)}$<br>\n",
    "………….<br>\n",
    "$dw + = x^{(m)}*{dz}^{(m)}$<br>\n",
    "$dw = \\frac{dw}{m}$<br>\n",
    "$db = 0$<br>\n",
    "$db + = {dz}^{(1)}$<br>\n",
    "$db + = {dz}^{(2)}$<br>\n",
    "………….<br>\n",
    "$db + = dz^{(m)}$<br>\n",
    "$db = \\frac{db}{m}$\n",
    "\n",
    "上述（伪）代码就是我们在之前实现中做的，我们已经去掉了一个**for**循环，但用上述方法计算 $dw$ 仍然需要一个循环遍历训练集，我们现在借鉴前向传播中将样本**for**循环向量化的方法，将反向传播向量化！"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**向量化**\n",
    "\n",
    "$Z = w^{T}X + b = np.dot( w.T,X)+b$<br>\n",
    "$A = \\sigma( Z )$<br>\n",
    "$dZ = A - Y$<br>\n",
    "${{dw} = \\frac{1}{m}*X*dz^{T}\\ }$<br>\n",
    "$db= \\frac{1}{m}*np.sum( dZ)​$<br>\n",
    "$w: = w - a*dw$<br>\n",
    "$b: = b - a*db$<br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 逻辑回归损失函数\n",
    "## **损失函数：**\n",
    "\n",
    "损失函数又叫做误差函数，用来衡量算法的运行情况，**Loss function:$L\\left( \\hat{y},y \\right)$.**\n",
    "\n",
    "逻辑回归中用到的损失函数是：$L\\left( \\hat{y},y \\right)=-y\\log(\\hat{y})-(1-y)\\log (1-\\hat{y})$\n",
    ">* 当$y=1$时损失函数$L=-\\log (\\hat{y})$，如果想要损失函数$L$尽可能得小，那么$\\hat{y}$就要尽可能大，因为**sigmoid**函数取值$[0,1]$，所以$\\hat{y}$会无限接近于1。\n",
    "* 当$y=0$时损失函数$L=-\\log (1-\\hat{y})$，如果想要损失函数$L$尽可能得小，那么$\\hat{y}$就要尽可能小，因为**sigmoid**函数取值$[0,1]$，所以$\\hat{y}$会无限接近于0。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "回想一下，在逻辑回归中，需要预测的结果$\\hat{y}$,可以表示为$\\hat{y}=\\sigma(w^{T}x+b)$，$\\sigma$是我们熟悉的$S$型函数 $\\sigma(z)=\\sigma(w^{T}x+b)=\\frac{1}{1+e^{-z}}$ 。\n",
    "\n",
    "我们约定 $\\hat{y}=p(y=1|x)$ ，即算法的输出$\\hat{y}$ 是给定训练样本 $x$ 条件下 $y$ 等于1的概率。\n",
    "\n",
    "换句话说，如果$y=1$，在给定训练样本 $x$ 条件下$y=\\hat{y}$；\n",
    "\n",
    "反过来说，如果$y=0$，在给定训练样本$x$条件下 $y$ 等于1减去$\\hat{y},即(y=1-\\hat{y})$，因此，如果 $\\hat{y}$ 代表 $y=1$ 的概率，那么$1-\\hat{y}$就是 $y=0$的概率。即:<br>\n",
    "$\\begin{cases}if&y=1:&p(y=1|x)=\\hat y\\\\if&y=0:&p(y=0|x)=1-\\hat y\\end{cases}$\n",
    "\n",
    "上述的两个条件概率公式可以合并成如下公式：\n",
    "\n",
    "$p(y|x)={\\hat{y}}^{y}{(1-\\hat{y})}^{(1-y)}$\n",
    "\n",
    "第一种情况，假设 $y=1$，由于$y=1$，那么${(\\hat{y})}^{y}=\\hat{y}$，因为 $\\hat{y}$的1次方等于$\\hat{y}$，${(1-\\hat{y})}^{(1-y)}$的指数项$(1-y)$等于0，由于任何数的0次方都是1，$\\hat{y}$乘以1等于$\\hat{y}$。因此当$y=1$时 $p(y|x)=\\hat{y}$。\n",
    "\n",
    "第二种情况，当 $y=0$ 时 $p(y|x)$ 等于多少呢?\n",
    "假设$y=0$，$\\hat{y}$的$y$次方就是 $\\hat{y}$ 的0次方，任何数的0次方都等于1，因此 $p(y|x)=1×{(1-\\hat{y})}^{1-y}$ ，前面假设 $y=0$ 因此$(1-y)$就等于1，因此 $p(y|x)=1×(1-\\hat{y})$。因此在这里当$y=0$时，$p(y|x)=1-\\hat{y}$。\n",
    "\n",
    "刚才的推导表明 $p(y|x)={\\hat{y}}^{(y)}{(1-\\hat{y})}^{(1-y)}$，就是 $p(y|x)$ 的完整定义。由于 log 函数是严格单调递增的函数，最大化 $log(p(y|x))$ 等价于最大化 $p(y|x)$ 并且地计算 $p(y|x)$ 的 log对数，就是计算 $log({\\hat{y}}^{(y)}{(1-\\hat{y})}^{(1-y)})$ (其实就是将 $p(y|x)$ 代入)，通过对数函数化简为：\n",
    "\n",
    "$ylog\\hat{y}+(1-y)log(1-\\hat{y})$\n",
    "\n",
    "而这就是我们前面提到的损失函数的负数 $(-L(\\hat{y},y))$ ，前面有一个负号的原因是当你训练学习算法时需要算法输出值的概率是最大的（以最大的概率预测这个值），然而在逻辑回归中我们需要最小化损失函数，因此最小化损失函数与最大化条件概率的对数 $log(p(y|x))$ 关联起来了，因此这就是单个训练样本的损失函数表达式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## **$m$个训练样本的整个训练集对应的代价函数**\n",
    "\n",
    "假设所有的训练样本服从同一分布且相互独立，也即独立同分布的，所有这些样本的联合概率就是每个样本概率的乘积:\n",
    "\n",
    "$P\\left(\\text{labels  in training set} \\right) = \\prod_{i =1}^{m}{P(y^{(i)}|x^{(i)})}$。\n",
    "\n",
    "如果你想做最大似然估计，需要寻找一组参数，使得给定样本的观测值概率最大，但令这个概率最大化等价于令其对数最大化，在等式两边取对数：\n",
    "\n",
    "$logp\\left( \\text{labels  in  training set} \\right) = log\\prod_{i =1}^{m}{P(y^{(i)}|x^{(i)})} = \\sum_{i = 1}^{m}{logP(y^{(i)}|x^{(i)})} = \\sum_{i =1}^{m}{- L(\\hat y^{(i)},y^{(i)})}$\n",
    "\n",
    "在统计学里面，有一个方法叫做最大似然估计，即求出一组参数，使这个式子取最大值，也就是说，使得这个式子取最大值，$\\sum_{i= 1}^{m}{- L(\\hat y^{(i)},y^{(i)})}$，可以将负号移到求和符号的外面，$- \\sum_{i =1}^{m}{L(\\hat y^{(i)},y^{(i)})}$，这样我们就推导出了前面给出的**logistic**回归的成本函数$J(w,b)= \\sum_{i = 1}^{m}{L(\\hat y^{(i)},y^{\\hat( i)})}$。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 练习搭建神经网络\n",
    "## 环境和库包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import h5py#一个操作h5文件的通用包\n",
    "import scipy\n",
    "from lr_utils import load_dataset\n",
    "from scipy import ndimage\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 问题分析\n",
    "我们能够获得数据为:\n",
    "1. 标记了是否有猫的训练集；\n",
    "2. 标记了是否有猫的测试集；\n",
    "3. 每一个图片文件的数据结构为（num_px，num_px，3），其中3指的是RGB三原色的的数据结构，每一张图片都是一个高度和宽度相等为64的方形图片。\n",
    "\n",
    "基于上面的数据，我们建立一个能够识别图片是否有猫图片识别模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 加载数据\n",
    "train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$$\\left ( 209, \\quad 64, \\quad 64, \\quad 3\\right )$$"
      ],
      "text/plain": [
       "(209, 64, 64, 3)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_x_orig.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([b'non-cat', b'cat'], dtype='|S7')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = [1], 这是一个 'cat' picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 随机抽取样本集中的图片\n",
    "index = 2\n",
    "plt.imshow(train_set_x_orig[index])\n",
    "print (\"y = \" + str(train_set_y[:, index]) + \", 这是一个 '\" + classes[np.squeeze(train_set_y[:, index])].decode(\"utf-8\") +  \"' picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x_flatten=train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T\n",
    "test_set_x_flatten=test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/latex": [
       "$$\\left ( \\left ( 12288, \\quad 209\\right ), \\quad \\left ( 1, \\quad 209\\right ), \\quad \\left ( 12288, \\quad 50\\right ), \\quad \\left ( 1, \\quad 50\\right )\\right )$$"
      ],
      "text/plain": [
       "((12288, 209), (1, 209), (12288, 50), (1, 50))"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_x_flatten.shape,train_set_y.shape,test_set_x_flatten.shape,test_set_y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**数据标准化**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(255, 0)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_set_x_flatten.max(),train_set_x_flatten.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set_x=train_set_x_flatten/255\n",
    "test_set_x=test_set_x_flatten/255"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**数据加工要点：**\n",
    "1. 了解数据规模和数据的结构\n",
    "2. 按照矩阵的要求，整理数据的结构\n",
    "3. 数据标准化"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 模型结构\n",
    "\n",
    "<img src=\"images/LogReg_kiank.png\" style=\"float:left;width:650px;height:400px;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**模型表达式**:\n",
    "\n",
    "以$x^{(i)}$为例:<br>\n",
    "$z^{(i)} = w^T x^{(i)} + b$<br>\n",
    "$\\hat{y}^{(i)} = a^{(i)} = sigmoid(z^{(i)})$<br>\n",
    "$ \\mathcal{L}(a^{(i)}, y^{(i)}) =  - y^{(i)}  \\log(a^{(i)}) - (1-y^{(i)} )  \\log(1-a^{(i)})$<br>\n",
    "\n",
    "训练样本集的代价函数（成本函数）:<br>\n",
    "$ J = \\frac{1}{m} \\sum_{i=1}^m \\mathcal{L}(a^{(i)}, y^{(i)})$\n",
    "\n",
    "**关键步骤:**\n",
    "1. 初始化模型的参数w、b；\n",
    "2. 通过最小化代价函数值学习最优的参数；\n",
    "3. 使用最优参数预测测试集；\n",
    "4. 分析预测结果并给出结论；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 构建模型的各功能模块\n",
    "建立神经网络的主要步骤为:\n",
    "1. 定义模型的结构；\n",
    "2. 初始化模型的参数；\n",
    "3. 梯度下降迭代：\n",
    "    * 正向传播，计算代价函数值；\n",
    "    * 反向传播，计算梯度下降值；\n",
    "    * 用梯度下降值更新模型的参数；\n",
    "    \n",
    "### sigmoid函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# sigmoid\n",
    "def sigmoid(z):\n",
    "    s = 1 / (1 + np.exp(-z))    \n",
    "    return s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5       , 0.73105858])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sigmoid(np.array([0,1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参数初始化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# initialize_with_zeros\n",
    "def initialize_with_zeros(dim):\n",
    "    w = np.zeros((dim, 1))\n",
    "    b = 0\n",
    "    assert(w.shape == (dim, 1))\n",
    "    assert(isinstance(b, float) or isinstance(b, int))    \n",
    "    return w, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0.],\n",
       "        [0.],\n",
       "        [0.]]), 0)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dim=3\n",
    "w,b=initialize_with_zeros(dim)\n",
    "w,b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 前向和后向传播函数\n",
    "**前向传播：**\n",
    "\n",
    "* 计算$Y$的估计值$A = \\sigma(w^T X + b) = (a^{(0)}, a^{(1)}, ..., a^{(m-1)}, a^{(m)})$\n",
    "* 代价函数值： $J = -\\frac{1}{m}\\sum_{i=1}^{m}y^{(i)}\\log(a^{(i)})+(1-y^{(i)})\\log(1-a^{(i)})$\n",
    "\n",
    "**反向传播:**\n",
    "\n",
    "* $ \\frac{\\partial J}{\\partial w} = \\frac{1}{m}X(A-Y)^T$\n",
    "* $ \\frac{\\partial J}{\\partial b} = \\frac{1}{m} \\sum_{i=1}^m (a^{(i)}-y^{(i)})$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# propagate\n",
    "def propagate(w, b, X, Y):    \n",
    "    m = X.shape[1]#样本量\n",
    "    A = sigmoid(np.dot(w.T, X) + b)#真实标签值的估计值\n",
    "    cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))#成本函数值\n",
    "    dw = 1 / m * np.dot(X, (A - Y).T)\n",
    "    db = 1 / m * np.sum(A - Y)\n",
    "    assert(dw.shape == w.shape)\n",
    "    assert(db.dtype == float)\n",
    "    cost = np.squeeze(cost)\n",
    "    assert(cost.shape == ())    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}    \n",
    "    return grads, cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dw = [[0.99993216]\n",
      " [1.99980262]]\n",
      "db = 0.49993523062470574\n",
      "cost = 6.000064773192205\n"
     ]
    }
   ],
   "source": [
    "w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])\n",
    "grads, cost = propagate(w, b, X, Y)\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print (\"cost = \" + str(cost))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 优化(梯度下降)函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# optimize\n",
    "def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):    \n",
    "    costs = []    \n",
    "    for i in range(num_iterations):\n",
    "        grads, cost = propagate(w, b, X, Y)\n",
    "        dw = grads[\"dw\"]\n",
    "        db = grads[\"db\"]\n",
    "        w = w - learning_rate * dw\n",
    "        b = b - learning_rate * db\n",
    "        if i % 100 == 0:\n",
    "            costs.append(cost)\n",
    "        if print_cost and i % 100 == 0:\n",
    "            print (\"Cost after iteration %i: %f\" %(i, cost))  \n",
    "    params = {\"w\": w,\n",
    "              \"b\": b}    \n",
    "    grads = {\"dw\": dw,\n",
    "             \"db\": db}    \n",
    "    return params, grads, costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w = [[0.1124579 ]\n",
      " [0.23106775]]\n",
      "b = 1.5593049248448891\n",
      "dw = [[0.90158428]\n",
      " [1.76250842]]\n",
      "db = 0.4304620716786828\n",
      "[6.000064773192205]\n"
     ]
    }
   ],
   "source": [
    "params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)\n",
    "print (\"w = \" + str(params[\"w\"]))\n",
    "print (\"b = \" + str(params[\"b\"]))\n",
    "print (\"dw = \" + str(grads[\"dw\"]))\n",
    "print (\"db = \" + str(grads[\"db\"]))\n",
    "print(costs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 预测函数\n",
    "$\\hat{Y} = A = \\sigma(w^T X + b)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# predict\n",
    "def predict(w, b, X): \n",
    "    m = X.shape[1]\n",
    "    Y_prediction = np.zeros((1,m))\n",
    "    w = w.reshape(X.shape[0], 1)\n",
    "    A = sigmoid(np.dot(w.T, X) + b)\n",
    "    for i in range(A.shape[1]):\n",
    "        if A[0, i] <= 0.5:\n",
    "            Y_prediction[0, i] = 0\n",
    "        else:\n",
    "            Y_prediction[0, i] = 1\n",
    "    assert(Y_prediction.shape == (1, m))    \n",
    "    return Y_prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "predictions = [[1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "print (\"predictions = \" + str(predict(w, b, X)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 用模块函数搭建模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# model\n",
    "def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5, print_cost = False):\n",
    "    w, b = initialize_with_zeros(X_train.shape[0])#初始化模型参数\n",
    "    # 训练模型获得最优参数\n",
    "    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)\n",
    "    w = parameters[\"w\"]\n",
    "    b = parameters[\"b\"]\n",
    "    Y_prediction_test = predict(w, b, X_test)#预测测试集\n",
    "    Y_prediction_train = predict(w, b, X_train)#预测训练集\n",
    "    print(\"训练集的准确率: {} %\".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))\n",
    "    print(\"测试集的准确率: {} %\".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))    \n",
    "    d = {\"costs\": costs,\n",
    "         \"Y_prediction_test\": Y_prediction_test, \n",
    "         \"Y_prediction_train\" : Y_prediction_train, \n",
    "         \"w\" : w, \n",
    "         \"b\" : b,\n",
    "         \"learning_rate\" : learning_rate,\n",
    "         \"num_iterations\": num_iterations} \n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cost after iteration 0: 0.693147\n",
      "Cost after iteration 100: 0.584508\n",
      "Cost after iteration 200: 0.466949\n",
      "Cost after iteration 300: 0.376007\n",
      "Cost after iteration 400: 0.331463\n",
      "Cost after iteration 500: 0.303273\n",
      "Cost after iteration 600: 0.279880\n",
      "Cost after iteration 700: 0.260042\n",
      "Cost after iteration 800: 0.242941\n",
      "Cost after iteration 900: 0.228004\n",
      "Cost after iteration 1000: 0.214820\n",
      "Cost after iteration 1100: 0.203078\n",
      "Cost after iteration 1200: 0.192544\n",
      "Cost after iteration 1300: 0.183033\n",
      "Cost after iteration 1400: 0.174399\n",
      "Cost after iteration 1500: 0.166521\n",
      "Cost after iteration 1600: 0.159305\n",
      "Cost after iteration 1700: 0.152667\n",
      "Cost after iteration 1800: 0.146542\n",
      "Cost after iteration 1900: 0.140872\n",
      "训练集的准确率: 99.04306220095694 %\n",
      "测试集的准确率: 70.0 %\n"
     ]
    }
   ],
   "source": [
    "d = model(train_set_x, train_set_y, test_set_x, test_set_y\n",
    "          , num_iterations = 2000, learning_rate = 0.005, print_cost = True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**备注：**\n",
    "1. 我们可以基于训练集的准确率，来检验模型是否准确。训练准确度接近100%，说明我们的模型搭建的没有逻辑bug；\n",
    "2. 测试集的准确率为70%，这个对于小样本的数据集，以及简单的逻辑回归算法来说；\n",
    "3. 通过训练集合和测试集预测准确度的偏差，说明模型存在过度优化的问题；"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 0, 预测的结果是: \"non-cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 例子\n",
    "index = 16\n",
    "num_px=64\n",
    "plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))\n",
    "print (\"y = \" + str(test_set_y[0,index]) + \", 预测的结果是: \\\"\" + classes[int(d[\"Y_prediction_test\"][0,index])].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 学习曲线即成本函数值\n",
    "costs = np.squeeze(d['costs'])\n",
    "plt.plot(costs)\n",
    "plt.ylabel('cost')\n",
    "plt.xlabel('iterations (per hundreds)')\n",
    "plt.title(\"Learning rate =\" + str(d[\"learning_rate\"]))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 不同的学习率"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "学习率: 0.01\n",
      "训练集的准确率: 99.52153110047847 %\n",
      "测试集的准确率: 68.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "学习率: 0.001\n",
      "训练集的准确率: 88.99521531100478 %\n",
      "测试集的准确率: 64.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n",
      "学习率: 0.0001\n",
      "训练集的准确率: 68.42105263157895 %\n",
      "测试集的准确率: 36.0 %\n",
      "\n",
      "-------------------------------------------------------\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEKCAYAAAD9xUlFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8VPW9//HXZ2Yyk2SSTDYIZCOA7AmChMW1VUvFVkHbiiDeq7cqt4v1Z29ttZut3t7W2k3bWlu01g3FrSptRVzbuoEEXNhlz8KSQEL2ZLJ8f3+cyWQSsieTySSf5+NxHpk55ztnPgkk7/me7znfI8YYlFJKKQBbqAtQSik1dGgoKKWU8tNQUEop5aehoJRSyk9DQSmllJ+GglJKKT8NBaWUUn4aCkoppfw0FJRSSvk5Ql1AbyUnJ5usrKxQl6GUUmFl8+bNx40xo7prF3ahkJWVRV5eXqjLUEqpsCIih3rSTg8fKaWU8tNQUEop5aehoJRSyi/sxhSUUgqgoaGB/Px86urqQl3KkBIZGUlmZiYRERF9er2GglIqLOXn52O32xk9ejQiEupyhgRjDNXV1eTn5zNx4sQ+7UMPHymlwlJdXR1ut1sDIYCI4Ha7+9V70lBQSoUtDYRT9fdnoqHQT5sPlbFx/4lQl6GUUgNCQ6EfTlTV8+WHN/Hdv24NdSlKqRB5/fXXWbBgAXPnzuXee+89ZXt9fT3XX389c+fO5aKLLiI/Px+A0tJSLrvsMsaNG8ett9462GV3SkOhH362bhfltQ3sP15NZV1DqMtRSg2ypqYmbrvtNtasWcM777zD888/z+7du9u0Wb16NfHx8WzatImvfOUr3HnnnQC4XC5uu+027rjjjlCU3ikNhT7asP8Ez24uZFZGPADbD1eEuCKl1GDbsmULWVlZZGVl4XQ6ueyyy1i3bl2bNuvWrePKK68E4NJLL+Wtt97CGIPb7WbBggW4XK5QlN6poJ6SKiKLgHsBO/CgMeaudtszgUeAeF+b24wxLwWzpoHgbWzmBy9sIz0hit8tn825d7/JtqJyFkxICnVpSo1Iv3rjELuLqwd0n1NGu/nWBeO6bHPkyBHS0tL8z1NTU9m8eXObNkePHvW3cTgcxMXFUVpaSlLS0Px7EbSegojYgfuAi4HpwHIRmd6u2Q+Ap40xs4FlwB+CVc9AevDt/ewtruKOxTPISIxmrCeSrUXloS5LKTXIjDGnrGt/9k9P2gwlwewpzAP2GmP2A4jIGmAJsCOgjQHifI89wOEg1jMgCkpr+O3re7hoRgoXTksBIDvNo6GgVAh194k+WFJTUykqKvI/P3z4MGPGjGnTZuzYsRQVFZGamkpjYyMVFRUkJCQMdqk9FswxhTSgIOB5oW9doB8DV4tIIfAS8I0g1tNvxhh+tHY7NhF+dOkM//qcNA8HjldTVd8YwuqUUoNt9uzZHDhwgEOHDuH1ennhhRdYtGhRmzaLFi3iqaeeAuBvf/sb55xzzojtKXT0XbfvRy0HHjbG/EpEzgQeE5FsY0xzmx2JrARWAmRmZgal2J5Yv/0Yb+wq5vufm0ZqfJR/fXZaHMbA9qJy5uu4glIjhsPh4Gc/+xlLly6lubmZ5cuXM3XqVO666y5mzZrFokWLWLFiBV/72teYO3cuCQkJrFq1yv/6M844g8rKSrxeL+vWreOZZ55hypQpIfyOghsKhUBGwPN0Tj08dB2wCMAY856IRALJQHFgI2PMKmAVQG5u7qkH6AZBdX0jd/xtO1PHxHLt2VlttmWneQDYdrhCQ0GpEWbhwoUsXLiwzbrbbrvN/zgyMpKHHnqow9du2bIlqLX1RTAPH20CJonIeBFxYg0kr23XJh+4EEBEpgGRQEkQa+qze177hCPldfzf5dlE2Nv+2EbHRpIS52KbjisopcJc0ELBGNMI3AisB3ZinWW0XUTuFJHFvmbfAm4QkY+AJ4FrTUdD9SG280gFD71zkOXzMpgzLrHDNjk62KyUGgaCep2C75qDl9qtuz3g8Q7g7GDW0F/NzYbvP78VT1QEty6a2mm77DQPr+8qprq+EbdLZyRXSoUnvaK5G0/lFbAl/yTf+9w04qOdnbbLSfNgDOw4olc2K6XCl4ZCF05U1XPXul3MH5/IF89ofzZtWzm+weathXoISSkVvjQUuvDTl3ZRXd/ITy7L7va84tFxkYyO1cFmpVR401DoxIb9J3huSyErz5vApJTYHr1Gr2xWauTp69TZAPfccw9z585lwYIFvPHGG/71N910E9OmTePcc88dlO8hkIZCBwInvPvGBZN6/LrsNA/7Sqqo8eqVzUqNBP2ZOnv37t288MILvP322zz11FPceuutNDU1AbBs2TLWrFkz6N8PaCh06IG3rAnv7lwygyinvcevy0nz0GysU1iVUsNff6bOXrduHZdddhkul4tx48aRlZXlv5jtrLPOCtn8SHruZDsFpTX87g1rwrsLpqb06rWBg82dXc+glBp47rf+F0fJzgHdZ+OoaVSf+8Mu2/Rn6uwjR46Qm5vb5rVHjhwZwO+gb7SnEKCzCe96KiXORXKMi61F2lNQaiToz9TZQ3VKbe0pBGiZ8O4Hn2874V1PiQg5aXF6BpJSg6y7T/TB0p+ps3vy2lDQnoJPVeCEd2dl9Xk/OWke9hRXUuttGrjilFJDUn+mzl60aBEvvPAC9fX1HDp0iAMHDnDGGWeE4ttoQ0PB555XWya8y8Fh7/uPJds32KxXNis1/AVOnX322WezePFi/9TZL7/8MgArVqygtLSUuXPncv/99/PDH1q9mqlTp7J48WLOOeccrrzySu666y7sduvElpUrV3LxxRezd+9eZs6cyeOPPz5o35MMwfnnupSbm2vy8vIGdJ87Dldw6e/fZmluOj/7wsx+7etIeS1n/uwN7lg8g2v60eNQSnVt+/btpKT07mSQkeLYsWPMmNF2XFRENhtjcjt5id+I7yk0Nxt+8EL3E9711Ji4SJLcTh1XUEqFpREfCi0T3n2/mwnvekpE9MpmpVTYGtGhcDxgwrsvdDPhXW9Yg81V1DXoYLNSKryM6FD42Uu7qPE28n+Xdz/hXW9kp3loajZ6ZbNSKuyM2FB4b5814d0N507gtNE9m/Cup3LSffds1kNISqkwMyJDwdvYzA9f7P2Edz2V6okk0e3UcQWlVNgJaiiIyCIR2S0ie0Xktg62/0ZEPvQtn4jIyWDW06KvE971VOtgsx4+Umq4C8bU2Z3t88EHH2Tu3LmMGjWKEydOBOX7CVooiIgduA+4GJgOLBeR6YFtjDHfNMbMMsbMAn4H/DVY9bQoKK3ht6/vYdGMMb2e8K43ctLi2HOsUgeblRrGgjF1dlf7nDdvHs899xwZGRlB+56C2VOYB+w1xuw3xniBNcCSLtovB54MYj0YY7j9xW04bMKPFk/v/gX9kJ3qobHZsOtoZVDfRykVOsGYOrurfc6cOZPMzMygfk/BnBAvDSgIeF4IzO+ooYiMA8YDb3S0faCs336UN3eX8IPPT2Osp/cT3vVGdlrrYPOsjPigvpdSI93vt/+evRV7B3Sfp8Wdxo0zbuyyTbCmzu5un8EUzJ5CR+d4djanxjLgWWNMh8daRGSliOSJSF5JSUmfijlWfpxH//FHpo2N69eEdz2VnhBFfHSEnoGk1DAWjKmzQz2ldjB7CoVA4IGvdOBwJ22XAV/vbEfGmFXAKrDmPupLMb957r/YlnKAzyYWU9s0i1j7wJ6G2p41jbZe2azUYOjuE32wBGvq7FBOqR3MnsImYJKIjBcRJ9Yf/rXtG4nIFCABeC+ItXDTpb/lS7XwaulbLP7rJby0/6UOE3kgZad5+ORYJfWNOtis1HAUjKmze7LPYApaKBhjGoEbgfXATuBpY8x2EblTRBYHNF0OrDFB/gudOmo8t1++hieOnSSlrpJb37qVG169gYPlB4P2njlpHhqaDLt1sFmpYSkYU2d3tk+AVatWMXPmTA4fPsynPvUpbr755gH/nkbe1Nlbn6Xpuet4Judi7q0/RH1TPdflXMf1OdfjsrsGrlCs01/PvftN/u/ybFbMHzeg+1ZqpNOpszunU2f3Rs6XsC/4Osu2ruNvk69n4biF/PGjP3L5i5fzTtE7A/pW6QlReKJ0sFkpFT5GXigALLwDxp1D8svf4+eTruKBzz6AXex85bWvcMu/bqG4pnhA3sa6sjlOB5uVUmFjZIaCPQKu+AtEJcJTV7PAM5nnFj/H12d9nTfz32TxC4tZvXM1jc2N/X6r7DQPu49W4m1sHoDClVKBwu3w92Do789kZIYCQMxouPIxqDwKz12HU+x85fSv8PyS55k1ahZ3vX8XV/3jKraWbO3X27QMNn9yTAeblRpIkZGRVFdXazAEMMZQXV1NZGRkn/cRzOsUhr70XPjcL+Bv/w/e/D+48HYy4zK5/zP388qhV7j7/btZ8dIKlk5Zyk1n3EScM67Xb5Hju7J5a1G5/ypnpVT/ZWZmkp+fT3HxwBzuHS4iIyP7NRXGyA4FgDnXQtFmeOtXkDobpl2KiHBR1kWcnXo29314H0/seoJXD73KLbm3cMmES3p1dWFmYjRxkQ62FpWzPHjfhVIjTkREBBMnTgx1GcPOyD18FOjiX0DqGfD8V6HkE//qGGcMt867lTWfX0NaTBrfe/t7XP/K9ewv39/jXbdMo61nICmlwoGGAkBEpDW+4HDBUyugru19EKYlTeOxix/jhwt+yM7SnXxx7Rf57ZbfUtdY16Pd56R52HVEB5uVUkOfhkILT7p1RtKJffDCV6Hd4JXdZmfplKWsvWwti7IW8cDWB7j8xct5q/CtbnednebB29Ssg81KqSFPxxQCjT8PFt4Jr3wf3v41nPutU5okRyXzs3N/xmWnXcZPNvyEr73+NaYlTmOMewyjokYxKnqU/2tyVDKjo0czPTUGsKbR1sFmpdRQNvKmueiOMfDcdbDtr3D1c3DahZ029TZ5eWzHY7x/9H2Ka4o5Xnuck/Wn3lHULnaaGtx4XEnMGptJclRya3gEBEhSVBIRtojgfW9KqRGrp9NcaCh0xFsND34GKo/Ayn9CQlbPX9rk5XjtcUpqSzheY30trinmmQ93UG9OMm50E8U1xZTVlWHa3V5CEBIiExgVNYrk6GSSI62gSIpMIjEqkaTIJP/zeFc8dtvA319aKTU89TQU9PBRR5xuuPJxeOB8eOpq+PIr4Izu2UvtTlJjUkmNSW2zvvLIDh557xDvXHsREXYbDc0NlNaW+gOkpafREibFtcXsLdvLiboTHV5ZbRMb8a54f0gkRSWRGNk2OPxBEplEhF17IEqp7mkodCZpInzhQXhiKfz9m3D5H6Efdz/KTvPgbWxmz7EqpqfGEWGLIMWdQoq761kejTFUeCs4UXeC0tpSTtSd4ETtCf/X0jprXUFxAaV1pdQ21na4nzhnnD84EiMTSXAlkBDpW3yPEyMT/c81RJQamTQUujL5s/Dp78I/fwppc2D+yj7vKifgns3TU3t+ZbSI4HF58Lg8TPBM6LZ9TUPNKcHRPlD2ntzLybqTnKw/ecohrBaxEbHER8ZbYeGywiI+Mt7/uCVE4l3xJEYmEuWIGtRbBiqlgkNDoTvnfRsOfwDrvwtjcmDcmX3aTVaSmxiXdWXz0rkZ3b+gj6IjoomOiCYjtvv3aGpuotxbTlldmbXUW19L60o5WX+S0rpSyurKOFJ9hB2lOyirK6OhuaHDfbnsLjwuD/GueOJd8R0+TohMaLM+1hmLTfSsaKWGEg2F7ths8IU/warz4ZlrYOW/IG5sH3YjzEgN7TTaJ2u8/PrVT7jh3AlkJEZjt9n9h5N6whhDdUN1hwFSVlfGyXqr91FeX86+k/v8j5tMx7cjtYmNOGdcm+BoHyAep8ffU/I4PcS54oh2RGuvRKkg0VDoiUiPNfD84Gfg6f+Ea/8BDmevd5OT5uGxDYdobGrGYR/8T8iPvXeIR987xHv7TvDc184iLrJ34wYiQowzhhhnDBn0rLdjjKGyoZLyunJ/aLSEReDzk/UnOVZzjN1luymvL+90bATAIQ7iXHHEOeNOCYyWrx1ti3PG4bDpf3mluhLU3xARWQTcC9iBB40xd3XQZinwY8AAHxljrgpmTX2WMh2W/B6e/S/rUNLnf9XrXWSneahvbGZvSRVTx/R+xtX+aGo2PPl+PhOS3Rw4Xs2NT3zAQ9fkBj2cRIQ4p/UHuadBAlDXWOcPjwpvBRX1FZR7y/3Py+utx+XeckpqSth3ch/l9eVUNVR1ud+YiBirHl9IxDpjT/3q29aytKwb6Nu1KjUUBS0URMQO3AcsBAqBTSKy1hizI6DNJOC7wNnGmDIRGR2segZE9hes8YV3f2tNoDd7Re9e3jKNdmH5oIfCP3cXc7i8jj9efQYnaxq47a9bufPvO7hzSfag1tFTkY5IxjjGMMY9pleva2xupNJb6Q+MwBAJDJZKbyUV3goOVRyior6CCm8FdU1dz2XltDm7DBOPy0OsM5aYiBhinbFtl4hYPaNLhYVg9hTmAXuNMfsBRGQNsATYEdDmBuA+Y0wZgDFm6E+MfuGP4MiH1mmqKdOt6bZ7aEKyG7fTzraicq7IDd5gc0dWb8xnVKyLC6elEGG3sf94Nav+vZ+Jo2K45qysQa0lmBw2h//sqN7yNnmp8Fb4A6PSW0lFfevzwG0V3gqO1x7nQPkB//rOzuRqEWmPJMYZ0yYoYp2xresiYk8Jk5aAiYmIIToiWgfmVdAFMxTSgIKA54XA/HZtJgOIyDtYh5h+bIx5OYg19Z/dAV/6C6z6NDz1H9bAszupRy+1Bps9gz7YXFhWw5u7i7nx/NOI8B0uunXRVPaXVHPH37aTmRTN+VOGdidtMDjtTpKjkkmOSu71a5tNM9UN1VR5q6jwVlDVUEWlt7LN0n5dhbeCoqoi/+POzuxqIQgxEdaYjjvC7Q+LlnUxzhhiI2LbbnO2bo+NiMXtdOtUKqpLwQyFjk4Paf9RygFMAj4NpANviUi2MabNBEIishJYCfTrjkIDxp0MSx+FhxZZYwxX/9UKix7ITvPwxPuDO9j81KYCBFg2r/VnZ7cJ9y6bxRV/fI9vPPEBz331LKaMiR2UeoYjm9j8n+7H0vuz0wDqm+pbA8TrC5AG63l1Q3WbYGkJoBN1J8ivzPe/xtvs7fZ9WnosMRFWuPi/Ots9j4jB7Wz7PHCd0977ky3U0BfMUCiENiOL6cDhDtpsMMY0AAdEZDdWSGwKbGSMWQWsAmvuo6BV3BtpZ8Alv4YXv24tF/wA4rs/JJSTHkfdO83sK6kelD/CDU3NrNlUwPlTRpMWH9Vmm9vl4M/X5rLk9+/w5Yc38eKNZ5Mco4OpoeKyu3BFufrUU2nhbfJS1VBlhUpDJdXeaiobrMBoWd8mWBqqqG6oprSqlGpv6/POTiMOFGGLwB3hPjVYHG7cTrf1NaLtEh0R7W8b+FgDZugIZihsAiaJyHigCFgGtD+z6AVgOfCwiCRjHU7q+W3NQm321db9F965F7Y+A9MXw4KvQ8bcTl8SeM/mwQiF13Yco6SynhULOu5hjfVE8eA1uSz903usfDSPJ25YQGSETrQXrpx2J4n2nl970hFjDHVNdf7eSEt4VDVUUdNQ4w+OloAJDJeSmhIONhykuqGa6obqbgfvWzhsDn+4REdEdxgs0RHR1mOH23+RZuDzljbRjmg99bgfgvaTM8Y0isiNwHqs8YKHjDHbReROIM8Ys9a37bMisgNoAr5tjDkRrJqC4jM/gtwvw/t/gs2PwvbnIX0uLPgaTFt8ymGl8ckxRPsGm780Jz3o5a3emE9afBSfmtz5mMHM9Hh+s3QWX129he88+zH3LpulF4eNYCJClCOKKEdUv3otYJ0NVtNYQ7XXConqxmp/YHS0tIROTUMN5XXlFDUUUdNQQ3Wjta27wfwWLrvLCglHQFi0hE1AeJzy2GG1i3JEtdnmsrtGzO+ETp09kOor4cMnYMP9UHYAPBkwbyWc8Z8QFe9vdsUf38UYeParZwW1nAPHqzn/l//kls9O5sYLJnXb/r439/KL9bu5+TOTuPkzk4Nam1K91WyaqWuss0ImIEhqG2vbBktjjRUk3Tyvaayh2fTsFrl2sRPtiCYqIsofHN0FScu6jh5HO6KJdEQO6tlkOnV2KLhiYf5/w9zr4ZP1sOEP8OoP4Z93Wdc0zP8KJE1kRqqHpzYV0NRssNuC9+njyffzcdiEpT08/fVrn57I/pJq7nltD+OT3SyZlRa02pTqLZvY/J/4+9uDAeswWW1jLbWNtW2CIvBrYIgEtmtZX1xTbK3vQ28G8PfI2gROJyES5YjizNQzmZI4pd/fe1c0FILBZoepn7OWIx9ZPYe8v8D7D8CUizk/8QoebnCyv6SKSSnBGVeoa2jimbwCFk5PYXRcZI9eIyL89AvZFJTW8O1nPyYjMZozMnt/vr9S4UBE/CGTRM9OK+9O+6BpCYyaxhpqG05d598WsK66sZrjdcdbg6ihxj82c7vz9qCHgh4+GiyVR2HTg5D3ENScYHvzOGrn/De5n78eHAN/xs8LHxRx81Mf8vh18zlnUu8+VZVWe7nsvneo8Tby/NfOJiOxZzcYUkoFR1NzE3VNddjFTqSjZx/y2uvp4SO9PHKwxI6xTlv95naaL/ktLmki94PvwT058K+7ofr4gL7dExvzyUqK5qyJvf8ElOh28tC1c6lvbOb6R/KorOv6oiqlVHDZbXbcEe4+B0JvaCgMtogobLnXcGvKKv434SfWPRre/D/4zQxY+w0o3tnvt/jkWCXvHyzlqvmZ2Po4ZnHa6BjuXzGHvSVVfOPJD2hs6tmAnFIqvGkohEhOejxPnphE01XPwtc2wunL4OOn4Q8L4LHLYc9r0Ny3P8RPbMzHabfxpTn9m1/pnEnJ3LlkBv/cXcJP/tH/sFJKDX0aCiGSneahxtvEgeNVMHoqXHovfHMHXPBDOLYDVn8R7smGl78HBe/3OCBqvI08t6WQz+WMIdHd/6tEV8wfx3XnjOfhdw/y2HsH+70/pdTQpmcfhUjglc2njfadgeROgvNugbNugp1rYdtzsOkB2HAfxKXB9MtgxmWQlmvdEa4Df//oCJV1jVw1f9yA1fq9z03jwPFqfvy3HWQmufnU5FEDtm+l1NCiPYUQmTjKTWSEjW1FFadudDgh50uw/En49l64fBWMPd0KiD8v7LIHsXrjISaNjmFu1sCdSmq3Cb9dPptJo2O4cfUW9hyrHLB9K6WGFg2FEHHYbUwb24N7Nkd64PQruwmI70LB+2wrLOOjwnJWzM8c8EvyY1wO/nztXFwRdr78yCZOVNUP6P6VUkODhkII5aR52HG4gubmHl4r0mlAPAh/Xkj6I/P4sfMxvpRypM+D1F1Ji4/igf+cQ3FFPf/92GbqG7ufSVMpFV40FEIoO81DVX0jB05U9/7F7QKi9pI/sMWbydX214h5/OI2PYiBDIjZmQn8aunp5B0q47bnthJuFz8qpbqmA80h1DLYvK2onImjYvq+o0gPzzaeww/r4/nbDTPJqX7Pmq1104PW/EtxaTB9Ccy4vMtB6p66ZGYqB0qq+dWrnzAh2c03Lux+sj2lVHjQUAihSaNjcDlsbC0s79fkc8YYVm84RHZaHNkT0kGWwsylUFcBn7zcNiBiU2HSZ2DihTDhUxDVtwHpGy84jf3HrWAYP8rNJTNT+1y/Umro0FAIoR4PNndjS/5Jdh2t5KeX57QdYI6Ms8IhMCB2roXtL8KWR0FskHoGTLwATrsQ0uaAvWf37xUR7vpiDgWlNXzr6Y9IT4hmVkZ89y9USg1pOqYQYjlpHrb3ZrC5A6s3HiLG5WDxrC4+rbcExJWPw3f2w5dfgfO+YwXDW7+Ehy6CuyfAmhVWr6L0QLfv63LY+dN/zGF0nIsbHs2jvEbnSFIq3GkohFiOb7D5UGlNn15/ssbL3z8+wmWzU4lx9bDjZ3dA5nw4/7tw/atWSCx9FLK/AEc+hn98C347C+6dBX//H9j5d6un0YGkGBf3r5jDiap6fv3q7j59D0qpoUMPH4XYjLQ4wLqyeXyyu9evf3ZzId7GZq6a148rmKMSrIHo6UvAGOu+0/vesJaP1kDen0HskDHPOtQ08QJInW3dNwLrLKoV88fx2IZDLJ2bwYxUT99rUUqFVFB7CiKySER2i8heEbmtg+3XikiJiHzoW64PZj1D0eSUWJwOG9v6MK5gjOGJ9/M5IzOe6alxA1OQCCSfBvNXwlVr4NaDcO0/4JyboaEW3vwpPHihdajp6Wtg8yNwsoBbPjuF+Ggnt7+4vV+HwpRSoRW0noKI2IH7gIVAIbBJRNYaY3a0a/qUMebGYNUx1EXYbUwbE8vWwt6Hwob9pewvqeZXV5wehMp8HE7IOsdaLrzduu/D/n+29iR2vACAJ+k0nk2dyX37RrP+bbj43DOtgFFKhZVgHj6aB+w1xuwHEJE1wBKgfSiMeNlpHtZ+dBhjTK+mp1i98RCeqAg+P3NsEKtrx51szcuU8yXrUFPJLtj7Ohz4N+MLXudXznJ44480v5+CLfNMGHcWZC6AlGz/4Sal1NAVzFBIAwoCnhcC8zto90UROQ/4BPimMaaggzbDWk6ah9Ub8zl0ooasHo4rlFTWs377Uf5jQRaRESH6YysCo6dZy1k3Is3NfLJtE48+9SRXRhSSU7jJ35PAGWuNSYw7EzLPtE5/jYgKTd1KqU4FMxQ6+sjb/mDz34AnjTH1IvIV4BHgglN2JLISWAmQmZk50HWGXHbANNo9DYVnNhfQ0GS4av4Q+nnYbEyeOR/2R7NkYz5//8a5TI8uh/z3rOXQe/DGT3xtI6zB6paQyJgP0YmhrV8pFdRQKAQCb/2VDhwObGCMORHw9AHg5x3tyBizClgFkJubO+xGMSenxOK0W4PNl57e/ZXBzc2GJzbms2BCIqeN7sf0GEFyy2en8I+Pj/Cjtdt4+r/PRFouoAOoKbXmY8p/F/I3wHt/gHfutbaNmmYdamo55BQ/hAJPqREimKGwCZgkIuOBImAZcFVgAxEZa4w54nu6GBiR93x0OmxMHRvLtsM9G2z+954SCstquXWWDzbAAAAeNUlEQVTR1CBX1jfx0U5uXTSV2/66lec/KOILZ6S3boxOhCmLrAWsM5qKtrSGxLbnYPNfrG1x6dYhp7QzrCuvx54OrqEXgkoNJ0ELBWNMo4jcCKwH7MBDxpjtInInkGeMWQvcJCKLgUagFLg2WPUMdTNSPby09UiPBptXb8wnye3kohljBqm63luam8GTmwr46Uu7+Mz0FOIiO5k+IyIKss62FoDmJji23QqI/HehMA+2/9XaJjYYNdUKiDTfMnqGdYaUUmpASE+mPhaR27tpUmyM+ePAlNS13Nxck5eXNxhvNaie2JjP957fyr+/fT6ZSdGdtjtSXss5P3+TledNGLI9hRYfF55kyX3vcO1ZWfzo0hl931FVCRzeAkWbrV7F4S1Q4zvyaHfBmJzW3kTaHEg6rd8zwSo13IjIZmNMbnftetpTWIB1+Kezj7CPAIMSCsNV4D2buwqFpzYV0GwMy+cO/ePtM9PjWT4vk0ffO8TS3Aymje3jBXYxo2DyRdYC1qmwJw+1BkTRB/DBanh/lbXdFQepswJ6FHOs6cP1ugmlutXTUGgyxnQ8+Q0gIsNu8HewTR4TQ4Rd2FpU3ul1B41Nzax5v4BzJ43qMjiGkm9/dgrrth7h9hd9g84D8YdZBBKyrCX7C9a65iY4/okVFEWbrbB47z5o9k3S5x7dGhAt4xMxo/pfi1LDTE9Dobs/+hoK/eRy2JkyJrbL6S7e2FXM0Yo67ljSj0MxgyzB7eQ7i6by3b9u5YUPi7h8dnr3L+oLm731monZK6x1jfVwdJuvN+ELi0/W4//vGjPGOvTkX2ZC4ni9yE6NaD0NhQgR6azvL1gDyaqfctI8vLT1aKeDzas35pMS5+LCqaNDUF3fXZmbwZr3861B52kpxHY26DzQHC5In2MtLeoq4MhHcHRr67L/TWhutLZHuCFletugGD0dnOHRM1Oqv3oaChuAm7vYvm4AahnxstM8PPl+AYVltWQktv0jlH+ihn/vKeGmCybhsIfXIKrNJty5JJvL/vAO97y2hx9eMj10xUTGwfhzraVFYz2U7G4bFNueg7yHrO1iswavx+RY03WMmWk9jk0JzfegVBD15pRUHaULssB7NrcPhSc35SPAsnkZHbxy6Ds9I55lczN5+N2DXJGbztQxAzSr60BwuGDsTGtpYQyUF7QNisJNVli0cI9ud/gpBxInWverUCpM9fR/73z07KOgmzImFofNGmy+OKd1sNnb2MwzeQVcOC2FsZ7wnS/oOxdNYd22I9z+4naeWrlgYAadg0XEuqI6PhOmfr51fe1JOLatbVgEDmjbnZA82RrbGDXVOvQ0eirEZ+lpsios6NlHQ4jLYWdySuwp92x+ZcdRjld5WTGU5jnqgwS3k29fNIXvP7+NtR8dZsmstFCX1HtR8a1Tibdo9FpnPh3dCiU7oXgn5G+Erc+0tomI9oXF9NYB8dHT9FRZNeTo2UdDTE6ah1d2tB1sXr0hn/SEKM6bFP6nUC6bm8lTmwr4yT92csHU0YM36BxMDieMybaWQHUV1lhFS1AU7/Tdze6J1jauOF+PYmprYIyaBjGjNSxUSOjZR0NMdrqHp/IKKDpZS3pCNHuLq3hv/wm+fdEUbLbw/yNh9w06X/6Hd7j3tT38IJSDzsEWGQcZc60lUE2pdR+K4h1QvMsKi51/hy2PtraJSmztTYyaavUykidD7BgNCxVUA3H2kaBnHw2YwMHm9IRonnw/H4dNWJobngPMHZmVEc+VuRn85d2DXJGbwZQxsaEuaXBFJ1ozwY47q3WdMVBdEhAUO6zg+PhpqA84cuuMheRJvpCY1BoWieOtAXOl+kkHmoeYqQGDzZ+eMppnNxdyUfYYRsUOr1/47yyayrptR7n9xW2sGeqDzoNBxDpkFDMaJny6db0xUHEYTuyB43ussYvjn8DBt+DjNQGvt1tXeCdPahsWyZP1PhWqV3SgeYiJjLAzKSWWrUUV/OPjI5TXNoT9AHNHEn2Dzj94IYwHnQeDCHjSrGXCp9tuq6+EE3vh+N7WsDi+B/a9CU31re2ik07tWSRPgvhxevW2OoUONA9BOWlxvLazmKq6BiYkuzlzQlKoSwqK5fMyWbMpn5++tJMLp6UQ49Lz+3vFFWvdvS51dtv1zU1wMr9tz+L4Htj1EtQEjFvYIqzeRdJE6/qKpAm+rxOte1noKbQjkg40D0E5aR6eziuktNrLDz4/bdgeWrHbhP9dks3lf3iX376+h+99blqoSxoebHZrjCFxPEz+bNttNaW+sNgNJ/ZB6T44sR/2/wsaa1vb2V2+fbQLi8QJEJuqgTGM9XagubO/Ti8PTDkKYIZvsNnpsPGlOUGaQG6ImJ2ZwJW5GTz09gGumJPOpJQRNug82KITIXO+tQRqbobKI76QCAiL0n2w97W2h6McUb7AmBDQy/B91bOjwl6PQsEYc0ewC1Gtpo+Nw+mwcUnOWOKjh/9dxb6zqPVK5ydumD9se0ZDms3WOnYx/ry225qboKLo1LAo2W3NOttyNTdYEwomZFmh0TK9eYLvcXym3iUvDOhB3CEoMsLO0/99JuOT3KEuZVAkxbj49kVT+OGL2/n7x0e49PTUUJekAtnsrVN+TDy/7bamRmuOqMCwKDtoDYDvfQ0a6wIaC3jSA8IiKyA8xkNUgvYyhoAe3Y6zzzsXWQTcizXm8KAx5q5O2n0JeAaYa4zp8l6bw/V2nCNdU7Nh8e/f5nhVPa9/69M66DwcNDdD1TErJMoO+L4ehFLf4+ritu1dHkgYd2pYJGRZYWIfBle/h9BA346zLwXYgfuAhUAhsElE1hpjdrRrFwvcBGwMVi1q6Gu50vmL97/L717fw3d10Dn82WwQN9Zaxp156nZvdWtQBIZF8U745GVo8ra2Fbt1aCt+XGuvJXCJTdXZaQdIMH+K84C9xpj9ACKyBlgC7GjX7n+Bu4FbgliLCgNzxiVwxZx0/vz2Aa7ITee00TroPKw53ZAyw1raa27yDXwH9DBO5lvLvjetbYFnwtsc1uSC8ZkdB0dcql6T0UPBDIU0oCDgeSHWldF+IjIbyDDG/F1ENBQUt148lfXbj3L7i9tZfb0OOo9YNrt1yMiT3vaGSC0a66G8sDUoTh4KCI3XfaERuD9faCSMaxscngyIz4DYsXp4yieYodDRb7M/2kXEBvwGuLbbHYmsBFYCZGYOv6t7VavkGBe3XDSF21/czj+2HuGSmTrorDrgcFmnwSZN7Hh7Q511xlRgWJzMh7JDsOc1qDratr3YrGBoCSJPuhUYgc8j40fEQHjQBppF5Ezgx8aYi3zPvwtgjPmZ77kH2AdU+V4yBigFFnc12KwDzcNfU7Ph0t+9TWm1l9e/9SncOuisBlpDna+nccgKj/LC1p5HeaG1LnBMA6zJCNuERrvgiEsd0r2NkA80A5uASSIyHijCmlDvqpaNxphyILnluYj8E7ilu7OP1PBntwn/e9kMvnj/e/zujb3cdvHUUJekhpuISEg+zVo60txszVpbXmidctsSGuUF1nJ4C9ScaPciadvbiEu1Dll50qyvcakQkzLkxzaCFgrGmEYRuRFYj3VK6kPGmO0icieQZ4xZG6z3VuFvzrhEvjA7jYfeOcB/njmO1PjwvQ2pCkM2G8SmWEv6nI7beGt8vYzA0PD1No58CLtfanedBtZZVLFjfUHhC424tLYBEuLgCOp1CsGgh49GjoLSGi781b+4fHYaP//SzFCXo1TvGAO1Zb7DUYetAKkoan1c7nscOOcUtAZHXKq1+HsdqZCWaw2M98FQOHykVL9kJEazYkEmj7x7kBvOm8Bpo2NCXZJSPSdizTUVnQhjO/lQ0xIcHYVFRREc2w57XoGGGqv9Jb+B3C8HtWwNBTWkff3803h6UwG/emU391/dSTdeqXAVGBxjcjpuYwzUnbSCwj066CXp/LdqSEuOcXH9uRNYt+0oHxWcDHU5Sg0+EWteqJQZEDMq6G+noaCGvOvPHU+i28nd63eFuhSlhj0NBTXkxUZG8PXzT+OdvSd4e8/xUJej1LCmoaDCwtULMkmLj+LnL+8i3M6YUyqcaCiosOBy2PnmwslsLSpn3baj3b9AKdUnGgoqbFw+O41Jo2P45frdNDY1h7ocpYYlDQUVNuw24dsXTWH/8Wqe3VwY6nKUGpY0FFRYWTg9hdmZ8dzz2h7qGppCXY5Sw46GggorIsKti6ZytKKOR987GOpylBp2NBRU2FkwIYlPTR7FfW/uo7y2IdTlKDWsaCiosPTti6ZQXtvAA//eH+pSlBpWNBRUWMpO83Dp6an8+e0DFFfWdf8CpVSPaCiosPWthZNpaGrm92/sDXUpSg0bGgoqbGUlu7lybgZPbMzn0InqUJej1LCgoaDC2k0XTsJhF3796iehLkWpYUFDQYW1lLhI/uvs8bz44WG2Hy4PdTlKhb2ghoKILBKR3SKyV0Ru62D7V0Rkq4h8KCJvi8j0YNajhqevnDeRuEgHv1y/O9SlKBX2ghYKImIH7gMuBqYDyzv4o/+EMSbHGDMLuBv4dbDqUcOXJzqCr51/Gm/uLmHj/hOhLkepsBbMnsI8YK8xZr8xxgusAZYENjDGVAQ8dQM6J7Lqk2vOzCIlzsXd63fr1NpK9UMwQyENKAh4Xuhb14aIfF1E9mH1FG4KYj1qGIty2vl/F05m86EyXt9ZHOpylApbwQwF6WDdKR/hjDH3GWMmArcCP+hwRyIrRSRPRPJKSkoGuEw1XFyRm874ZDe/WL+bpmbtLSjVF8EMhUIgI+B5OnC4i/ZrgMs62mCMWWWMyTXG5I4aFfwbV6vwFGG38a3PTmb3sUpe/LAo1OUoFZaCGQqbgEkiMl5EnMAyYG1gAxGZFPD088CeINajRoDPZY8lOy2OX7/6CfWNOrW2Ur0VtFAwxjQCNwLrgZ3A08aY7SJyp4gs9jW7UUS2i8iHwP8A1wSrHjUy2GzCdy6aSmFZLU9uzA91OUqFHQm3MzVyc3NNXl5eqMtQQ5gxhqse2Mgnxyr513fOJ8blCHVJSoWciGw2xuR2106vaFbDjojwnUVTOFHt5aG3D4S6HKXCioaCGpZmZyZw0YwUVv17P6XV3lCXo1TY0FBQw9Ytn51CjbeRP7ypU2sr1VMaCmrYmpQSyxfPSOfRDYcoOlkb6nKUCgsaCmpYu3nhZDBw72s6tbZSPaGhoIa1tPgo/uPMcTy7uZA9xypDXY5SQ56Gghr2vn7+aUQ7HfzyFZ1aW6nuaCioYS/R7WTleRNYv/0YH+SXhbocpYY0DQU1Ilx3zniS3E5+/vIunVpbqS5oKKgRwe1y8I0LTmPD/lLe2nM81OUoNWRpKKgRY/n8TNITorh7/S6adWptpTqkoaBGDJfDzv8snMy2ogqezivo/gVKjUAaCmpEWTIrjQUTEvn+C9t4aeuRUJej1JCjoaBGFLtNePCauczKiOemJz9g/fajoS5JqSFFQ0GNODEuBw//11yy0zzc+MQWXt95LNQlKTVkaCioESk2MoJHr5vHtLFxfPXxLfxzd3GoS1JqSNBQUCNWXGQEj315PpNSYlj52Gbe2lMS6pKUCjkNBTWieaIjePy6+UxIdnP9I3m8u0+vYVAjW1BDQUQWichuEdkrIrd1sP1/RGSHiHwsIq+LyLhg1qNURxLcTlZfP59xSdFc93AeG/efCHVJSoVM0EJBROzAfcDFwHRguYhMb9fsAyDXGDMTeBa4O1j1KNWVpBgXq69fQGp8JP/18CbyDpaGuiSlQiKYPYV5wF5jzH5jjBdYAywJbGCMedMYU+N7ugFID2I9SnVpVKyLJ29YwJi4SK79yya26OR5agQKZiikAYGXjRb61nXmOmBdEOtRqluj4yJ54oYFJMU4uebP7/Nx4clQl6TUoApmKEgH6zqccEZErgZygV90sn2liOSJSF5JiZ4hooJrjMcKBk90BFc/uJFtReWhLkmpQRPMUCgEMgKepwOH2zcSkc8A3wcWG2PqO9qRMWaVMSbXGJM7atSooBSrVKC0+CievGEBsZERXP3njew4XBHqkpQaFMEMhU3AJBEZLyJOYBmwNrCBiMwG/oQVCHr1kBpSMhKjeeKG+URF2Ln6zxvZfVRv56mGv6CFgjGmEbgRWA/sBJ42xmwXkTtFZLGv2S+AGOAZEflQRNZ2sjulQmJckpsnbliAwyaseHADe4s1GNTwJuF2F6rc3FyTl5cX6jLUCLOvpIor/7QBEXhq5QImjIoJdUlK9YqIbDbG5HbXTq9oVqoHJo6K4ckb5tPcbFj+wAYOHq8OdUlKBYWGglI9NCklltU3zMfb2MxVD2ygoLSm+xcpFWY0FJTqhalj4nj8+vlUe5tYtmoDhWUaDGp40VBQqpdmpHp4/Lr5VNQ1cNUDGzlSXhvqkpQaMBoKSvVBTrqHx66bT1m1l+WrNnCsoi7UJSk1IDQUlOqjWRnxPPzleZRU1rP8gQ0UV2owqPCnoaBUP8wZl8DDX57H0fI6lq3awGMbDrHraAXNzeF1qrdSLfQ6BaUGwIb9J/ifpz7kcLnVW4iLdJCblUhuVgJzsxLJSfMQGWEPcZVqJOvpdQqOwShGqeFuwYQk3rntAgpKa9l0sJS8Q6VsOljGG7us2Vucdhsz0z3kZiUyNyuBOeMSiI92hrhqpU6lPQWlgqi02svmQ2XkHSxl08FSthaV09Bk/c5NSYn19yRysxJIi49CpKPJhZXqv572FDQUlBpEtd4mPio86QuJMrYcKqOyvhGAsZ5If08id1wiU8bEYrdpSKiBoYePlBqCopx2FkxIYsGEJACamg27j1b6DzdtOlDK3z6yZpiPjXQwZ1wCp6fHk5kYTUZiNBmJUaTERmLTsFBBoqGgVAjZbcL01Dimp8bxn2dmYYyhsKzWHxJ5B0v51yclBHbonXYbaQlRpCdEkZ5gBUVGgi80EqJIdDv1MJTqMw0FpYYQEfH1CKK5fLZ1y/L6xiYOn6yjoLSGgrIaCkprKSirobC0hvWHj1Ja7W2zj2in3RcSLaFhhUVGYjTpCVHERkaE4ltTYUJDQakhzuWwMz7Zzfhkd4fbq+obKWwJi4DgKCyr4b19J6j2NrVpHx8dQUZCNKnxkYyJiyTFY30dExfJGI+1RDv1T8NIpf/ySoW5GJeDqWPimDom7pRtxhjKahpO6WUUlNawr6Sad/ee8A90B4qNdPhDIiXu1PBI8bhIdrt0bGMY0lBQahgTERLdThLdTk7PiO+wTXV9I0cr6jhWXsfRirp2j+vZc+w4JVX1NLW7StthE0bHuvxhkeILkVExLpJjXSTHOBkV6yIx2onDrpMnhAsNBaVGOLfLwcRRMUzs4m5yTc2G41X1HPWFxbGKujaPPzlWyVt7jlPVQa9DBBKjnSTHuEiOdVqh4Q+O1vAYFeMi0a0BEmpBDQURWQTcC9iBB40xd7Xbfh5wDzATWGaMeTaY9Sil+sZuE1J8vYHTu2hXVd/I8cp6jlfVU9LytcrL8ap6jlfWU1JVz+b8Mo5XeqltaDrl9SKQEO30B0VyTOuS5HaS4HaS6I4g0W31QGIjHXoIa4AFLRRExA7cBywECoFNIrLWGLMjoFk+cC1wS7DqUEoNnhiXgxiXg6xOBsUDVdc3WmHhC5CSKq8/UKzFywf5JzleVU+N99QAASusEqIjSHQ7SYh2+g+VtTxPimldn+B2kuR26hxU3QhmT2EesNcYsx9ARNYASwB/KBhjDvq2NQexDqXUEOR2OXC7HIxL6j5AaryNlFZ7KatuoLTGS2l1PaXVDZRVezlR7aWs2ktpjZc9xVWUVXspq/HS2US1URF2f3DER0cQH+0kPiqig8cReKKcvq8RRIyQw1rBDIU0oCDgeSEwP4jvp5QapqKdDqKdDtITeta+udlQUdfQGhgtS423XZA0UFhWy8kaL+W1DZ0GCVi9IE9AYMRHOfFER7SGSMBzT3QEcZERxEVF4Hbaw+piwmCGQkc/hT5NtCQiK4GVAJmZmf2pSSk1AthsYn3qj3bCqJ69prnZUFnfyMkaLydrGjhZ2+APi5M1vqXWS7lv267yCv+2xi7SxG4T4iIdxEW1BIUVLi2h0bLNE7C9dVsEkRG2QQ2VYIZCIZAR8DwdONyXHRljVgGrwJoQr/+lKaVUWzab4PH9cR6X1PPXGWOo9ja1hklNAxV1DVTUtnxtpLw2cF0jxRVVVNQ1UF7bQF1D10fPnXabPyhuXjiZxaen9vM77VowQ2ETMElExgNFwDLgqiC+n1JKDToR8Q+w9/TwVqD6xiYq6xr9gVFe2zZQWsKjoraBhOjgT1EStFAwxjSKyI3AeqxTUh8yxmwXkTuBPGPMWhGZCzwPJACXisgdxpgZwapJKaWGGpfDjivGTnKMK9SlAEG+TsEY8xLwUrt1twc83oR1WEkppdQQMDLOsVJKKdUjGgpKKaX8NBSUUkr5aSgopZTy01BQSinlp6GglFLKT0NBKaWUnxgTXrNGiEgJcKiPL08Gjg9gOcEWTvWGU60QXvWGU60QXvWGU63Qv3rHGWO6nQkq7EKhP0QkzxiTG+o6eiqc6g2nWiG86g2nWiG86g2nWmFw6tXDR0oppfw0FJRSSvmNtFBYFeoCeimc6g2nWiG86g2nWiG86g2nWmEQ6h1RYwpKKaW6NtJ6CkoppbowYkJBRBaJyG4R2Ssit4W6ns6ISIaIvCkiO0Vku4j8v1DX1BMiYheRD0Tk76GupSsiEi8iz4rILt/P+MxQ19QVEfmm7//BNhF5UkQiQ11TIBF5SESKRWRbwLpEEXlVRPb4vvbh1jMDr5Naf+H7v/CxiDwvIvGhrLFFR7UGbLtFRIyIJAfjvUdEKIiIHbgPuBiYDiwXkemhrapTjcC3jDHTgAXA14dwrYH+H7Az1EX0wL3Ay8aYqcDpDOGaRSQNuAnINcZkY92salloqzrFw8CidutuA143xkwCXvc9Hwoe5tRaXwWyjTEzgU+A7w52UZ14mFNrRUQygIVAfrDeeESEAjAP2GuM2W+M8QJrgCUhrqlDxpgjxpgtvseVWH+00kJbVddEJB34PPBgqGvpiojEAecBfwYwxniNMSdDW1W3HECUiDiAaPp4n/NgMcb8Gyhtt3oJ8Ijv8SPAZYNaVCc6qtUY84oxptH3dAND5KZfnfxcAX4DfAcI2mDwSAmFNKAg4HkhQ/wPLYCIZAGzgY2hraRb92D9R+36DuShNwEoAf7iO9T1oIi4Q11UZ4wxRcAvsT4VHgHKjTGvhLaqHkkxxhwB60MOMDrE9fTUl4F1oS6iMyKyGCgyxnwUzPcZKaEgHawb0qddiUgM8BxwszGmItT1dEZELgGKjTGbQ11LDziAM4D7jTGzgWqGzqGNU/iOxS8BxgOpgFtErg5tVcOTiHwf69Dt6lDX0hERiQa+D9zeXdv+GimhUAhkBDxPZ4h1wwOJSARWIKw2xvw11PV042xgsYgcxDosd4GIPB7akjpVCBQaY1p6Xs9ihcRQ9RnggDGmxBjTAPwVOCvENfXEMREZC+D7WhzierokItcAlwArzNA9R38i1oeDj3y/a+nAFhEZM9BvNFJCYRMwSUTGi4gTa7BubYhr6pCICNYx753GmF+Hup7uGGO+a4xJN8ZkYf1c3zDGDMlPs8aYo0CBiEzxrboQ2BHCkrqTDywQkWjf/4sLGcID4wHWAtf4Hl8DvBjCWrokIouAW4HFxpiaUNfTGWPMVmPMaGNMlu93rRA4w/d/ekCNiFDwDSTdCKzH+qV62hizPbRVdeps4D+wPnF/6Fs+F+qihpFvAKtF5GNgFvDTENfTKV+P5llgC7AV6/d1SF2BKyJPAu8BU0SkUESuA+4CForIHqwzZe4KZY0tOqn190As8Krvd+2PIS3Sp5NaB+e9h25vSSml1GAbET0FpZRSPaOhoJRSyk9DQSmllJ+GglJKKT8NBaWUUn4aCkoppfw0FJQKMhH5k4icHeo6lOoJvU5BjWgi8mOsKcpbZsp0YM2W2dE6erPeGPNj33t8CHwR60rfAwFvn4x1Ffg/2q83xizo33emVN84Ql2AUkPAspYptH03Wbm5k3Wdte10vYhMw5qnvwl4wBhzT8ubikjL487WKzXo9PCRUsF1MfByqItQqqc0FJQKrovQUFBhRENBqSDxzYEfb4wZstO0K9WehoJSwXM+8Gaoi1CqNzQUlAoeHU9QYUdDQangOQt4J9RFKNUbekqqGumKgUdFpNn33Ib16b6jdfRmvTEm8FafXmCJiHw6YF1zF+uVCgm9eE0ppZSfHj5SSinlp6GglFLKT0NBKaWUn4aCUkopPw0FpZRSfv8fSgYlMOP8rn4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "learning_rates = [0.01, 0.001, 0.0001]\n",
    "models = {}\n",
    "for i in learning_rates:\n",
    "    print (\"学习率: \" + str(i))\n",
    "    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)\n",
    "    print ('\\n' + \"-------------------------------------------------------\" + '\\n')\n",
    "\n",
    "for i in learning_rates:\n",
    "    plt.plot(np.squeeze(models[str(i)][\"costs\"]), label= str(models[str(i)][\"learning_rate\"]))\n",
    "\n",
    "plt.ylabel('成本值')\n",
    "plt.xlabel('迭代次数/百次')\n",
    "\n",
    "legend = plt.legend()\n",
    "frame = legend.get_frame()\n",
    "frame.set_facecolor('0.90')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 预测一个非数据集图片"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\env\\pythonve\\test36\\lib\\site-packages\\ipykernel_launcher.py:5: DeprecationWarning: `imresize` is deprecated!\n",
      "`imresize` is deprecated in SciPy 1.0.0, and will be removed in 1.3.0.\n",
      "Use Pillow instead: ``numpy.array(Image.fromarray(arr).resize())``.\n",
      "  \"\"\"\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "y = 0.0, 模型预测结果是： \"non-cat\" picture.\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "my_image = \"my_image.jpg\"   # 图片的名称\n",
    "# 整理图片数据\n",
    "fname = \"images/\" + my_image\n",
    "image = np.array(plt.imread(fname))\n",
    "my_image = scipy.misc.imresize(image, size=(num_px,num_px)).reshape((1, num_px*num_px*3)).T\n",
    "my_predicted_image = predict(d[\"w\"], d[\"b\"], my_image)\n",
    "plt.imshow(image)\n",
    "print(\"y = \" + str(np.squeeze(my_predicted_image)) + \n",
    "      \", 模型预测结果是： \\\"\" \n",
    "      + classes[int(np.squeeze(my_predicted_image)),].decode(\"utf-8\") +  \"\\\" picture.\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {
    "height": "420.98px",
    "width": "485.014px"
   },
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
